Process control with digital twins

ABSTRACT

Real time process control using digital twins. In more detail, the present disclosure relates to the field of modeling distributed event-discrete systems using digital twins and subsequent use of the models for real time control of distributed even-discrete systems. There is provided a virtual twin engine for control of a distributed even-discrete system in real-time. The virtual twin engine has installed at least one executable modeling software kernel which runs subsystem use models in relation to subsystem clusters of the distributed event-discrete system. Also, the virtual twin engine operates the at least one digital twin in a passive manner through real time access to the modeling software kernel modeling the subsystem use model of the at least one digital twin.

FIELD OF INVENTION

The present invention relates to the field of real time process controlusing digital twins. In more detail, the present invention relates tothe field of modeling distributed event-discrete systems using digitaltwins and subsequent use of the models for real time control ofdistributed even-discrete systems.

BACKGROUND ART

Real time process control in manufacturing is an ongoing challenge andsubject to continuous development. FIG. 1 shows a typically example of amanufacturing environment subject to real-time process control.

As shown in FIG. 1, the considered manufacturing environment may, e.g.,comprise a first line 1. The first line 1 may be setup from threeconveyers, i.e. conveyer 11, conveyer 12, and conveyer 13, each providedwith a sensor 11, 12, and 13, respectively.

As shown in FIG. 1, the considered manufacturing environment may, e.g.,also comprise a second line 2. The second line 2 may be setup from threeconveyers, i.e. conveyer 21, conveyer 22, and conveyer 23, each providedwith a sensor 21, 22, and 23, respectively.

As shown in FIG. 1, the conveyer 11 of line 1 carries a box and theoverall object of the process control could be a safe movement of thebox along the line 1.

FIG. 2 shows a hierarchical tree model which is a typical model used forthe process control of the manufacturing environment shown in FIG. 1.

As shown in FIG. 2, in the hierarchical tree model different subsystemsof the process environment are represented as nodes. Typically, thehierarchical tree model is prepared prior to start of process control.The assignment of a subsystem to a hierarchy level in the hierarchicaltree model may be application specific and different layers in thehierarchical tree model are usually operated in independent manner.

Further, there is no option to modify the generated hierarchical treemodel once the process control starts as subsystems of the manufacturingenvironment are hard coded into the hierarchical tree model withoutflexibility. Should, e.g., a new line be set up for the manufacturingenvironment or should the application thereof change then this wouldrequire a complete recoding of the hierarchical tree model underlyingthe process control. Also a change in functionality of the differentsubsystems would necessitate a remodeling process for the hierarchicaltree model.

However, in view of increasing complexity of process environments theexisting approaches to process control no longer meet requirements forfuture application scenarios.

SUMMARY OF INVENTION

In view of the above, the object of the present invention is to increaseflexibility in the modeling of distributed event discrete systems forsubsequent efficient real time process control thereof.

According to a first aspect of the present invention this object isachieved by a method of running a virtual twin engine for control of adistributed even-discrete system in real-time, wherein the virtual twinengine has installed at least one executable modeling software kernel.

According to the first aspect of the present invention the at least oneexecutable modeling software kernel is prepared by generating a metamodel representation for at least one subsystem of a distributedevent-discrete system by selecting from a meta model a meta object typereferencing at least one state model for modeling of the at least onesubsystem of the distributed event-discrete system, wherein at least onestate in the selected at least one state model is described with a metamodel being a set of partial states using different levels of dataabstraction according to set of meta features characterizing a state ina meta description domain, a set of target features having discrete orcontinuous range of values characterizing a target for a consideredstate, and a set of actual features having discrete or continuous rangeof values characterizing an actual constellation of a considered state.

Further, according to the first aspect of the present invention the atleast one executable modeling software kernel is prepared bypartitioning the distributed event-discrete system into at least twosubsystem clusters each comprising at least one subsystem of thedistributed event-discrete system having a same meta modelrepresentation and by defining a routing topology for the exchange ofstreaming messages between subsystem clusters.

Further, according to the first aspect of the present invention the atleast one executable modeling software kernel is prepared by modeling atleast one subsystem use cluster for at least one subsystem assigned to asubsystem cluster of the distributed event-discrete system and byconfiguring the at least one executable modeling software kernel to runthe routing topology and at least one subsystem use model in relation toevery subsystem use of the subsystem cluster through parametrization ofexecutable software available from a software library.

Further, according to the first aspect of the present invention themethod of running the virtual twin engine comprises a step of running inreal time at least one subsystem use model in relation to the subsystemcluster through execution of a related modeling software kernel modelingthe at least one subsystem use model and a step of operating at leastone digital twin with respect to the at least one subsystem use model asvirtual counterpart to a related process object operated in thedistributed even-discrete system and having a functionality in line withthe subsystem use model.

Further, according to the first aspect of the present invention the stepof operating the at least one digital twin is executed in a passivemanner through real time access to the modeling software kernel modelingthe subsystem use model of the at least one digital twin.

According to a second aspect of the present invention the objectoutlined above object is achieved by a virtual twin engine for controlof a distributed even-discrete system in real-time, wherein the virtualtwin engine has installed at least one executable modeling softwarekernel.

According to the second aspect of the present invention the at least oneexecutable modeling software kernel is prepared as in the first aspectof the present invention.

According to the second aspect of the present invention the virtual twinengine comprises a model processing module adapted to run in real timeat least one subsystem use model in relation to the subsystem clusterthrough execution of a related modeling software kernel modeling the atleast one subsystem use model; wherein

According to the second aspect of the present invention the modelprocessing module is adapted to operate at least one digital twin withrespect to the at least one subsystem use model as virtual counterpartto a related process object operated in the distributed even-discretesystem and having a functionality in line with the subsystem use model;and

According to the second aspect of the present invention the modelprocessing module is adapted to operate the at least one digital twin ina passive manner through real time access to the modeling softwarekernel modeling the subsystem use model of the at least one digitaltwin.

BRIEF DESCRIPTION OF DRAWING

In the following the present invention and related examples will beexplained with reference to the drawing in which:

FIG. 1 shows a typically example of a manufacturing environment subjectto real-time process control;

FIG. 2 shows an outline of a typical model underlying process control ofthe manufacturing environment shown in FIG. 1;

FIG. 3 shows examples of modeling on a meta model layer using metaobjects as types of meta models of subsystems;

FIG. 4 shows examples of modeling on a use model layer or equivalentlytemplate layer to define clusters of meta models of subsystems;

FIG. 5 shows examples of modeling on a twin layer to describe subsystemsas instances of clusters of meta models of subsystems;

FIG. 6 shows a result of modeling on a meta level as shown in FIG. 3 incombination with modeling on a use level as shown in FIG. 4 and incombination modeling on a twin layer as shown in FIG. 5;

FIG. 7 shows a general outline of a state space model used according tothe present invention for the modeling of distributed event-discretesystems;

FIG. 8 shows a further detailed representation of the state space modelshown in FIG. 7;

FIG. 9 shows a further detailed representation of the state space modelshown in FIG. 7;

FIG. 10 shows an overview for on a system adapted to model a distributedevent-discrete system and to execute real time process control of thedistributed even-discrete systems according to the present invention;

FIG. 11 shows a basic flowchart of operation for the system adapted tomodel a distributed event-discrete system and to execute real timeprocess control of the distributed even-discrete systems according tothe present invention;

FIG. 12 shows a schematic diagram of a computer implemented meta modelaccording to the present invention which is used by the modeling engineshown in FIG. 10;

FIG. 13 shows a flowchart of operation for the modeling engine accordingto the present invention as shown in FIG. 10;

FIG. 14 shows a partitioning of a distributed event-discrete systemaccording to the present invention, wherein the partitioning is definedas a set of subsystem clusters such that all subsystems assigned to aspecific subsystem cluster are modeled with a same meta object type;

FIG. 15 shows a schematic diagram of a service engine according to thepresent invention, wherein the service engine generates a use model ofat least one subsystem of a distributed event-discrete system in linewith a meta object type used to model the at least one subsystem;

FIG. 16 shows a flowchart of operation for the use level modelingaccording to the present invention as shown in FIG. 14 and FIG. 15,respectively.

FIG. 17 shows a schematic diagram of a virtual twin engine according tothe present invention, wherein the virtual twin engine has pre-installedat least one executable modeling software kernel prepared by the serviceengine as shown in FIG. 15;

FIG. 18 shows a flowchart of operation for the virtual twin engineaccording to the present invention as shown in FIG. 17;

FIG. 19 shows further details of operation for a module processingmodule as operated in the virtual twin engine;

FIG. 20 shows a further schematic diagram illustrating the operation ofthe virtual twin engine according to the present invention,

FIG. 21 shows a further detail flowchart of operation for the data flowprocessing module shown in FIGS. 17 and 20, respectively;

FIG. 22 shows an example of a seed-box approach to an evaluation ofstate vectors and condition vectors in the data flow processing moduleaccording to the present invention as shown in FIG. 17;

FIG. 23 shows a further example of the seed-box approach to theevaluation of state vectors and condition vectors in the data flowprocessing module according to the present invention as shown in FIG.17; and

FIG. 24 shows an example of updating a seed-box as shown in FIGS. 22 and23 after execution of a sate transition with respect to a twin object.

DETAILED DESCRIPTION OF INVENTION

In the following, the present invention will be explained in detail withreference to the drawings. Here, it should be understood that suchexplanation is related to examples of the present invention only and notbinding to the scope of the present invention as defined by the claims.

As far as reference is made to specific procedural or structuralcomponents, this is to be considered as example for the underlyingfunctionality, where the procedural or structural components are clearlyexchangeable as long as the same functionality is achieved. Thus, thepresent invention will be explained using generic terminology to avoidrestriction of the scope of protection.

Further, the functionality of the process control using digital twinsaccording to the present invention is manifold. It not only supports aflexible modeling of distributed event-discrete systems but also a realtime process control of the distributed event-discrete systems.

Generally, a distributed event-discrete system to be considered withinthe overall framework of the present invention divides into a pluralityof subsystems where each single subsystem operates autonomously and doesnot always have a complete picture on the overall operative states inthe distributed event-discrete system.

Further, a distributed event-discrete system may categorize, e.g., intoa continuous system, a discrete system deterministic system, stochasticsystem, dynamic system, real valued system, causal system, linearsystem, non-linear system, time invariant system, time variant system,stable system, BIBO stable system, loss free system, etc. or anysuitable combination thereof.

Further, the term process in a subsystem of the distributedevent-discrete system describes a sequence of events with a mutuallyfixed causal time relationship. This implies the causaldistinguishability of events within subsystems of the distributedevent-discrete system: two different local events in a subsystem shouldnever occur at the same point in time.

In view of the above, events are classified into three classes:

A first class relates to internal events occurring within a subsystem ofthe distributed event-discrete system without external transmission ofmessages.

A second class relates to sending events occurring within a subsystemtriggering the sending of messages from the subsystem to differentsubsystems of the distributed event-discrete system. From a globalperspective they precede corresponding receiving events in differentsubsystems to which the messages are addressed.

A third class relates to receiving events occurring within subsystemsupon receipt of messages from different subsystems of the distributedevent-discrete system. From a global perspective they succeedcorresponding sending events in different subsystems from which themessages are sent.

Generally, the modeling of distributed event-discrete systems is basedupon a tradeoff between handling of a predetermined task and relatedefforts versus implied complexity of the overall model. In particular,the way of set up of particular partial systems for the model and therelated connection contributes to the model complexity.

Here, in the state of the art, a typical approach is a hierarchicalstructuring and decomposition for a specific modelling task. Generally,in the state of the art, subsystems are modeled in a compositionalmanner, i.e. in a any-to-any approach. While the compositionalstructuring of the model increases the adaptability of the modelaccording to new modeling goals, it increases the complexity of themodel, in particular due to the high number of signaling connectionsbetween the subsystems.

Contrary to the prior art, the modeling approach according to thepresent invention supports modeling and process control of a distributedevent-discrete system aligned for a dynamic modification of the overallsystem model in real-time.

As will be shown in the following, heretofore the present invention usesdifferent levels of abstraction and modeling of the distributedevent-discrete system, i.e. a meta level, a use level, and a twin levelallowing for a partitioning of the overall distributed event-discretesystem into partial systems which then are further specified topped downaccording to a virtual hierarchy or specifications.

FIG. 3 shows examples of modeling on a meta model layer using metaobjects as types of meta models of subsystems.

As shown in FIG. 3, meta models use transformation functions orequivalently a language range, semantics describing meta states, andstate space models describing a logical behavior.

Generally, the meta model highlights properties of an actual model.Thus, meta modeling is a construction of concepts within a certainapplication domain. Meta modeling typically involves studying input andoutput relationships and fitting of meta models to represent a givenbehavior.

Further, the relation between the digital twin level and the metal modellevel is of an instance-of-relation type. Also, the relation between theuse level and the meta model is of an instance-of-relation type.

As shown in FIG. 3, meta modeling implies the abstraction away fromspecific real world instantiations on the basis of meta objects. For theparticular example shown in FIG. 3, the meta objects are a meta objectconveyer and a meta object sensor.

Then, for the meta object conveyer, the related functionality may bedescribed using a state diagram, e.g. representing the ON/OFF state ofthe conveyer motor.

As shown in FIG. 3, also a sensor may be abstracted away from the realworld and again be described through a related state diagramcharacterizing typical states of the sensor in general, i.e. a statewhere a measurement is completed and a state where a signal is analyzedand related state transition to analyze the signal into duo measurement,respectively.

As shown in FIG. 3, yet another important aspect of the presentinvention is a meta representation of states on different levels ofabstraction. As shown in FIG. 3, such an abstracted state representationfor the meta object conveyer would be, e.g. a meta state signalanalyzed, a specification of a target feature to a target velocity, anda specific representation of an actual feature showing the actual speedof the conveyer during run time.

As shown in FIG. 3, similarly, the meta state representation for themeta object sensor may be again be a categorizing feature being signalanalyzed, a target feature to specify that the detection result state isgiven, and as an actual feature, an object ID to be object ID equalID3456.

FIG. 4 shows examples of modeling on a use model layer or equivalentlytemplate layer to define clusters of meta models of subsystems.

Here, the object is to define use objects as cluster of digital twinobjects such that all digital twin objects within a cluster share acommon set of descriptive features, a common subset of globally validevents, a common set of states and a common set of state models.

Here, clusters of meta models of subsystems use a common language scope,semantics and behavior of meta models of subsystems as well as a commonset of meta data, features and properties.

As shown in FIG. 4, the use level modeling differs over the meta levelmodeling in that it is more specific about the actual use of conveyersand sensors described in an abstract matter on the meta level.

As shown in FIG. 4, therefore the use model of the conveyer line recitesdifferent uses of the conveyer, i.e. a first to third use. Similarly,there are described four uses of a sensor.

Further, on the use layer, there are also introduced so-called externalstate vectors implying an operation upon indication of a certain statein the overall system, e.g. the conveyer use one function as switched ONwhen the state of the sensor use one is such that it indicates that asignal is analyzed.

As shown in FIG. 4, yet another aspect of use level modeling accordingto the present invention to be described in more detail in the followingis the set-up of clusters. Here, the identified uses of different systemcomponents like conveyer and sensors are summarized in so-called useclusters such that different meta object types are assigned to a relatedcluster, respectively. Then, the exchange of information between useclusters is achieved on so-called meta streams.

As shown in FIG. 4, each use cluster sends external signals as a metastream, i.e. the use cluster conveyer sends external signals on thestream conveyer while the use cluster sensor sets external signals onthe stream sensor. Further, each use cluster listens to external signalsfrom at least one meta stream being different from its own sending metastream, e.g. the use cluster conveyer listens to external signals of usecluster sensor on the stream sensor. Otherwise, within the use cluster,there may also be exchanged internal signals.

The use level modeling and the set-up of use clusters and related metastream therebetween according to the present invention is of significantimportance to reduce complexity during real-time process control of theoverall distributed event-discrete system. The reason for this is that,contrary to an any-to-any routing topology, the number of components tobe addressed is given by the number of clusters, not by the number ofactual components of the system.

FIG. 5 shows examples of modeling on a twin layer to describe subsystemsas instances of clusters of meta models of subsystems.

Here, each instance maps the logical behavior of a subsystem. In thefollowing digital twin level instances will equivalently referred to asdigital twins.

Thus, a third level of abstraction in the modeling of distributedevent-discrete systems according to the present invention is anabstraction level named digital twin level.

Here, the object is to define digital twin objects of real world processobjects which model real world devices, data, messages, taskspecifications etc.

The outcome of the twin layer modeling is shown as example in FIG. 5.Here, it is assumed that two conveyer lines are set up.

As shown in FIG. 5, for the conveyer there are three use scenarios,nevertheless, six twin instantiations such that twin 1 to twin 3 of theconveyer set up the conveyer line 1, while twin 4 to twin 6 of theconveyer set up conveyer line 2.

Further, for the sensor use, there are specified four uses with respectto conveyer line 1 and 2, respectively. Then, for each sensor use thereare two twins t1, t4 further t2, t5, further twin 3, twin 7, and finallytwin 4, twin 8.

As can be seen in from FIG. 5, only at determination of the modeling onthe twin layer, a full model of the distributed event-discrete system isgenerated.

FIG. 6 shows a result of modeling on a meta level as shown in FIG. 3 incombination with modeling on a use level as shown FIG. 4 and incombination with modeling on a twin layer as shown in FIG. 5.

As shown in FIG. 6, the complete system shown in FIG. 5 is modelledacross three layers of abstraction, i.e. the meta model objectrepresentation used for set-up of clusters like the cluster conveyer andthe cluster sensor, then, the use level modelling to categorize use ofsystem components characterized on the meta level according to the typeof meta modeling, and then followed by instantiation of the differentuse scenarios for each cluster on the twin level.

As shown in FIG. 6, the interoperation between different system clustersis then achieved on the basis of meta streams in relation to thedifferent clusters so as to significantly reduce the overall load forexchange of information during the real-time process control of theoverall distributed event-discrete system, to be described on a moredetailed level in the following.

FIG. 7 shows a general outline of a state space model used according tothe present invention for the modeling of distributed event-discretesystems.

Generally, according to a state model a system is described by an inputvector x=(x1, . . . , xk) T∈X, an output vector y=(y1, . . . , yn)T∈Y,and a system operator S mapping the input vector x to the output vectory according to y=S(x).

In more detail, the mathematical model uses state variables to modelsystem states which are summarized into a state variable vector z=(z1, .. . , zm) T∈Z.

The composition of the input vector x, the state variable vector z, andthe output vector y may be represented using at least two functions:

A first function is a state transition function Φ: Z×X→Z whichdetermines a transition to target state(s) z′∈Z as a function of aninitial state(s) z∈Z and an input vector x∈X at occurrence of a systemevent to describe the dynamic behavior of the system.

The second function is an output function Ω: Z×X→Y which determines anoutput vector y∈Y as a function of the state variable vector z∈Z and theinput vector x∈X.

Optionally, for some types of event discrete systems there may bedefined a third function being a retention time function τ: Z→R+defining the retention time with respect to a state variable vector z∈Z.

Further, it should be noted that with respect to the existence and typeof input vectors x an empty input vector x corresponds to an autonomoussystem or equivalently a data generator. Also, an empty input vector xin combination with an empty output vector y relates to systems that maybe described by a Markov Chain model.

As shown in FIG. 7, a characteristic according to the present inventionis the type of representation of a state in the state model. Accordingto the present invention it is suggested to have different types ofabstraction for state representation according to meta level, targetlevel, and actual level, as exemplified above in FIG. 3.

These different types of abstraction for state representation accordingto the present invention allow for a significant reduction of complezityin the handling of the process control of the distributed event-discretesystem. The reason for this is that while, e.g. the target of a subsystem used to specify a control behavior might be in the real-timedomain and thus be of infinite number of values. Nevertheless, onabstraction of a way of such a real range into meta level types of, e.g.low speed, medium speed, high speed, will then lead to a reduction ofcomplexity in the handling of, e.g. a conveyer line as described above.

FIG. 8 shows a further detailed representation of the state space modelshown in FIG. 7.

As shown in FIG. 8, a state transition function Φ may be decomposed atleast into an external state transition into Φex to describe statetransitions due to system external events, respectively.

In more detail, as shown in FIG. 8, according to the present inventionthere is considered a state where a state transition in a first subsystem is influenced by states of further subsystems not being identicalwith the first sub system.

As shown in FIG. 8, there may be considered a state model for a specificsub system and a related transition ΦEX triggered by an external statevector summarizing an identification of external subsystems and relatedstates to, e.g. SS 1, st 1, . . . , SS n, st n. Assuming that each ofthese subsystem is in the specified state, then, according to thepresent invention, there is considered an external state transitionwithin the subsystem in line with the external state vector.

The concept of the external state vector implies a trigger for statetransition within a specific subsystem and supports parallelization inthe process of system modeling with respect to interaction betweensubsystems of the distributed event-discrete system. The external statevectors may be set up in a flexible manner to increase or decreasegranularity on the level of conditions securing a state transition in aspecific subsystem.

FIG. 9 shows a further detailed representation of the state space modelshown in FIG. 7.

As shown in FIG. 9, a state transition function Φ may further bedecomposed at least into an internal external state transition into Φinto describe state transitions due to system internal events.

As shown in FIG. 9, also the internal state transition is triggered byconsideration of the state representation of at least one state withinthe system. Assuming that a state representation is prevailing whichtriggers a state transition, then the overall state space modelrepresentation of the sub system may be updated. It should be noted thatthe change of an internal state within a specific sub system mayconstitute an external event to a remote sub system and trigger a statetransition in the remote sub system as explained above with respect toFIG. 4.

In view of the above, in the following there will be explained amodeling of a distributed event-discrete systems in general as basis foran understanding of the principles underlying the present invention.

In more detail, state model of a distributed event-discrete system isdefined by a 7-tuple Σ=<X, Z, Y, Φin, Φex, Ω, τ, wherein

-   -   X is the finite set of input vectors x∈X;    -   Z is the finite set of state variable vectors z∈Z;    -   Y is the finite set of output vectors y∈Y;    -   Φn: Z→Z is the state transition function for internal events;    -   Φex: Z×X→Z is the state transition function for external events;    -   Ω: Z×X→Y is the output function; and    -   τ: Z→R+ is the retention time function.

According to the present invention input vectors x∈X to distributedevent-discrete systems are called external events. Upon occurrence of anexternal event the system state z∈Z may change to z′∈Z according to

z′(t)=Φex(x(t),z0(t)).

Here z0(t)∈Z is the initial state of the distributed event-discretesystem or initial state in short and z′(t) is the target state of thedistributed event-discrete system or target state in short.

Further, as outlined above with respect to FIG. 9 state transitionswithout input are generated due to internal events which may occur overtime. The distributed event-discrete system remains in the state z overa retention time τ(z). Upon expiry of the retention time τ(z) there isgenerated a new state which is determined by the internal statetransition function according to

z′(t+τ(z))=Φin(z(t)).

Further, upon occurrence of a state transition also the output vector isupdated according to

y(t)=Ω(z(t),x(t)).

where z(t) is again the initial state. It should be noted that x(t) maybe the zero vector when no inputs or equivalently no external eventsprevail.

As mentioned above, the retention time function τ determines theduration of every partial state zi∈z=(z1, . . . , zm)T. Any change in apartial state implies a change of the state variable vector z∈Z.

Assuming that ti is the starting time of partial state zi and that τ1, .. . , τm are the retention times for the partial states z1, . . . , zmas determined at the starting time ti, then the retention time functionfor partial state zi at time ti may be determined according to

τ(zi)=min(τ1, . . . ,τm).

Generally, according to the present invention it is assumed that eventsin distributed event-discrete system occur at random points in time sothat state transitions may be calculated using stochastic state models.A special case of a distributed event-discrete system then may be thedeterministic time discrete state model having sample time tA whereτ(zi)=tA for i∈(1, . . . , m) and ti=tj for all i, j∈(1, . . . , m) withi≠j.

On the basis of the explanations given above in the following there willbe described principles of deriving a meta model for distributedevent-discrete systems according to the present invention.

As exemplified above with respect to FIG. 3, on the meta modeling levelthere are specific types of meta models referred to as meta object typesin the following which serve to model specific types of subsystems ofthe distributed event-discrete system.

In more detail, according to the present invention a meta object typespecifies a meta model of state representations and related semantics.Meta object types also specify transformation functions or equivalentlya language range and a logic behavior of the subsystem being modeledthrough reference to at least one corresponding state space model.

In the following it is assumed—without loss of generalization—that wemodel a subsystem SS with a meta object MO having a specific but not yetfixed meta object type ●.

Thus ● is to be understood as placeholder for a meta object type orequivalently as characterizing a meta model type template.

The instantiation of a generic meta object type to a specific usethereof is then achieved through parametrization of the placeholder ●where different use scenarios are handled by multiple parametrizations.

According to the present invention a first element of a meta model of ameta object type MO● is a representation object MO●R representing a setD●={d1●, . . . , do●} of descriptive features of the meta object typeMO●.

Further, according to the present invention in the meta model the atleast one meta object type MO● may be perceived under differentperspective views on the meta object type MO● being described a setP●=(p1●, . . . , pv●) of perspectives on a meta object type MO●.

According to the present invention a second element is at least one metaobject type MO● to model a subsystem of the distributed event-discretesystem, wherein the at least one meta object type MO● references atleast one state model Σi●i=1, . . . , s in relation to the subsystem.

In more detail, according to the present invention for each meta objecttype MO● the meta model specifies at least one state model Σi●i=1, . . ., s representing an event discrete system according to Σi●=<Xi●, Zi●,Yi●, Φini●, Φexi●, Ωi●, τi●> such that the overall state model of themeta model type MO● is Σ●=Ui Σi●.

The reason for the reference to than one state model Σi● by a metaobject type MO● is that one and the same meta object type MO● may beperceived under different criteria each forming a perspective view onthe meta object type MO● and the underlying subsystem to be modeled.From this it is meaningful to have one state model Σi● per perspectiveview used by the meta object type MO●. In the following the set ofperspectives on a meta object type MO● is described as P●={p1●, . . . ,pv●}.

Further, for each state model Σi● there exists a state variable vectorzi●=(zi●1, . . . , zi●z)T∈Zi●. According to the present invention eachk-th state in zi●, i.e. state zi●k in each state model Σi● may bedescribed using different levels of data abstraction like meta data,discrete values or continuous values for target values, and discrete orcontinuous values for actual values.

Thus, according to the present invention each state zi●k has a metamodel being a set of partial states zi●k,p described according to

-   -   at least one state zi●k in the at least one state model Σi● i=1,        . . . , s has a meta model being a set of partial states zi●k,p        using different levels of data abstraction according to    -   a set of meta features MFi●k,1={fc1, . . . , fcc}i●k,1        characterizing a state in a meta description domain;    -   a set of target features TFi●k,2={ft1, . . . , ftt}i●k,2 having        discrete or continuous range of values characterizing a target        for a considered state; and    -   a set AFi●k,3={fa1, . . . , faa}i●k,3 of actual features        AFi●k,3={fa1, . . . , faa}i●k,3 having discrete or continuous        range of values representing an actual constellation of a        considered state.

It should be noted that the use meta features characterizing a state ina meta description domain according to the present invention achieves anabstraction compared to the conventional state space representation. Theabstraction according to the present invention allows for a meta statespace representation. Here, each meta state space representation maysummarize an infinite number of state space representations into asingle meta state space representation and thus can significantly reducemodeling complexity.

Further, in the meta model a state transition in the i-th state modelΣi● of the meta object type MO● from a first state zi●a to a secondstate zi●t is achieved through a process described by a functional modelΦi●at: Zi●x Xi●→Zi●. Thus any state transition is assigned exactly toone state model Σi● and there is exactly one state transition from zi●ato zi●t. Here, according to the present invention the functional modelrepresents a data flow model according to meta features, target feature,and/or actual features. The data flow model describes a control flowoperating on meta data and a data flow operating on data reflectingtarget features and/or actual features.

It should be noted the functional model Φi●at generally applies to statetransitions due to external events and/or internal events being relevantto a specific meta object type MO● according to Φex,i●at and Φin,i●at,respectively.

Here, the functional model Φex,i●at represents a meta model of a statetransition triggered by at least one external event relevant for aspecific meta object type MO●. Further, it describes a data flow modelaccording to different levels of data abstraction, i.e. with respect tometa features, target feature, and/or actual features.

According to the present invention in the most general sense the dataflow model describes a control flow operating on meta data and a dataflow operating on data reflecting target or actual features. Theincorporation of data flow into the data flow model allows forspecification of conditions for state transitions.

Further, according to the present invention a first input to thefunctional model Φex,i●at is at least one vector of external states orequivalently external state vector Θex,i●at,l=((MOj, j≠●, zj), . . . ,(MOk, k≠●, zk))lT, where l is an index to the l-th external state vectorand each external state vector respectively summarizes tuples ofsubsystems external to a subsystem being modeled using the meta objettype MO● and corresponding states in which the external subsystemsindicated to prevail.

Thus, when a certain set of subsystems being external to a subsystemtype being modeled using the meta model type MO● and under considerationare in specific states, respectively, this may trigger a statetransition from zi●a to zi●t in one of the state models Σi● of the metaobject type MO● used for modeling a subsystem under consideration. Theidentification of the relevant state models Σi● and of the type of statetransitions will be explained in more detail in the following.

Further, the reason for consideration of more than one external statevector Θex,i●at,l, l>1, is that even if different subsystems prevail indifferent states, respectively, this may nonetheless trigger a samestate transition from zi●a to zi●t in the subsystem state model Σi● of ameta object type MO● under consideration.

Further, let πex,i●a=Ul Θex,i●at,l be the set of all external statevectors that may trigger a state transition with respect to the initialstate zi●a in state model Σi● of a meta object type MO●.

Further, according to the present invention a second input to thefunctional model is represented as a vector Δex,i●a summarizing a set ofconditions that must be met prior to triggering a state transition withrespect to the initial state zi●a in state model Σi● of a meta objecttype MO● due to an external event. Typically such conditions will bespecified of the basis data reflecting target features and actualfeatures.

Further, to conclude with meta modelling of meta object types MO●according to the present invention there is introduced a set of contextsC={con_ID1, . . . , con_IDk}.

Here, every context models a potential relation between two twin objectsrepresenting digital instantiations of meta object types MO●, or inother words a potential relation between instantiations of components ofthe distributed event-discrete system on a twin level as will beexplained in more detail below.

Generally, contexts are defined in relation to functional models and arevalid for all meta object types MO● which reference the functionalmodels. Also, contexts are assigned in an unambiguous manner to aperspective.

In view of the above, according to the present invention the functionalmodel Φex,i●at may be modelled as a meta model data flow according to:

Φex,i●at: zi●a∈Zi●x

-   -   πex,i●a×Δex,i●a×con_IDa x    -   MFi●a,1×TFi●a,2×AFi●a,3→    -   zi●t∈Zi●×con_IDt x    -   MFi●t,1×TFi●t,2×AFi●t,3

Further, according to the present invention a similar functional modelΦin,i●at may be modeled as a meta model data flow with respect to aninternal state transition in the meta object type MO● and its statemodel Σi● according to:

Φin,i●at: zi●a∈Zi●x

-   -   πin,i●a×Δin,i●a×con_IDa x    -   MFi●a,1×TFi●a,2×AFi●a,3→    -   zi●t∈Zi●×con_IDt x    -   MFi●t,1×TFi●t,2×AFi●t,3

In the above functional models representational elements may beidentified as follows:

-   -   zi●a∈Zi● is the source state selected from a set of all states        Zi● of the at least one state model Σi●i=1, . . . , s) of the        meta object type MO●;    -   zi●t∈Zi● is the target state selected from a set of all states        Zi● of the at least one state model Σi●i=1, . . . , s of the        meta object type MO●;    -   πex,ini●a is the set of the external or internal state vectors        triggering the state transition from the source state zi●a to        the target state zi●a;    -   Δex,ini●a is the vector of conditions triggering the state        transition from the source state zi●a to the target state zi●t;    -   con_IDa is context identification of the context prevailing for        the subsystem being modeled by the meta object type MO● prior to        the state transition from the source state zi●a to the target        state zi●t;    -   con_IDt is context identification of the context prevailing for        the subsystem being modeled by the meta object type MO● after        the state transition from the source state zi●a to the target        state zi●t;    -   MFi●a,1×TFi●a,2×AFi●a,3 is a representation of values for the        meta feature, target feature, and actual feature at the source        state zi●a prior to state transition to the target state zi●t;        and    -   MFi●t,1×TFi●t,2×AFi●t,3 is a representation of values for the        meta feature, target feature, and actual feature at the target        state zi●t after state transition to the target state zi●t.

In conclusion, according to the present invention irrespective on how aspecific transformation is realized it will operate on two levels ofabstractions, i.e. a control flow operating on meta data and a data flowachieving a link between meta data level, target conditions and actualconditions, e.g., captured by sensors. Thus, the introduction of acontrol flow operating on meta data allows to handle an infinite numberof states in a computational very efficient manner.

Further, it should be noted that a state transition may as well betriggered by a combination of at least one external event and at leastone internal event.

In the following different aspects of computer implemented metamodelling of a distributed event-discrete system and related use of thecomputer implemented meta model for real time process control of thedistributed event-discrete system will be described.

FIG. 10 shows an overview for on a system adapted to model a distributedevent-discrete system and to execute real time process control of thedistributed even-discrete systems according to the present invention.

As shown in FIG. 10, the system 10 according to the present inventioncomprises a modeling engine 12, a service engine 14, and virtual twinengine 16. The virtual twin engine 16 forms a virtual counterpart toreal world process objects.

Here, process objects are, e.g., field devices which are to becontrolled during operation of the distributed event-discrete system.Nevertheless, according to the present invention there is not imposedany restriction on the type of process object which may also be relatedto tasks to be achieved within the distributed event-discrete systemand, e.g., also model different types of information, etc.

Operatively, the modeling engine 12 drives a meta level model of thedistributed event-discrete system as outlined above. Once such metalevel model for the distributed event-discrete system is available, themodeling engine 12 issues a service request to the service engine 14.

Further operatively, the service 14 achieves a modeling of thedistributed event-discrete system on the use level as outlined above andfurther repairs an executable software skeleton reflecting the outcomeof the use level modeling of the distributed event-discrete system.

As also shown in FIG. 10, the modeling engine 12 and the service engine14 have an interface to the virtual twin engine 16.

Operatively, the service engine 14 forwards the executable softwareskeletons in relation to different types of component clusters asexplained above to the virtual twin engine 16 for pre-installationtherein. Also, the service engine 14 forwards the routing topologyderived during use level modeling of the distributed eventdiscrete-system to the virtual twin engine 16 for establishment ofrelated communication processes within the virtual twin engine 16 asexplained above.

As shown in FIG. 10, operatively, the modeling engine 12 may also injectcomponents of modeling to the virtual twin engine 16 in real-time and indynamic manner. This serves to modify the overall model of thedistributed event-discrete system in real-time so as to increaseflexibility of the modeling and process control method as will beexplained in more detail in the following.

FIG. 11 shows a basic flowchart of operation for the system adapted tomodel a distributed event-discrete system and to execute real timeprocess control of the distributed even-discrete systems according tothe present invention.

As shown in FIG. 11, initially, in a step S10 executed by the modelingengine 12, there is generated at least one meta object type in line withthe pre-configured static data model to be explained in the followingwith respect to FIG. 12.

Then, in a step S12 executed by the service engine 14, sub systems ofthe distributed event-discrete system are clustered according to metaobject type(s). Also, the service engine 14 executes a step S16 percluster object to generate sub clusters in relation to uses of metaobject type (s). Also, the service engine 14 achieves a specification ofa routing topology between different clusters.

As shown in FIG. 11, then follows a step S16 executed by the virtualtwin engine to run the generated model in real-time. Here, the virtualtwin engine 16 will allocate at least one twin object per meta objecttype use(s) and also use different levels of abstraction with respect todata representation as will be explained in more detail in thefollowing.

FIG. 12 shows a schematic diagram of a computer implemented meta modelwhich is used by the modeling engine according to the present inventionas shown in FIG. 10.

As shown in FIG. 12, a computer implemented meta model according to thepresent invention divides into a static meta model and into a dynamicmeta model. Here, the static meta model comprises a plurality ofentities respectively being a repository for build-up of a real-timecapable model of a distributed event-discrete system.

On the other hand, the dynamic meta model part of the computerimplemented meta model will reference at least partially the entities ofthe static meta model for transfer of modeling option provided by thedifferent entities into an actual meta model of a sub system of thedistributed even-discrete system.

As shown in FIG. 12, the static meta model of the computer implementedmeta model 18 for modelling at least one subsystem of a distributedevent-discrete system comprises at least one meta object entity 20describing a meta object type MO● used to model a subsystem of thedistributed event-discrete system.

As shown in FIG. 12, the at least one meta object entity 20 references astate space model entity 22 specifying at least one state model Σi● withi≥1 in relation to the subsystem. In the state space model entity 22 theat least one state zi●k in the at least one state model Σi● isrepresented by a meta model being a set of partial states zi●k,p usingdifferent levels of data abstraction according to

-   -   a set of meta features MFi●k,1={fc1, . . . , fcc}i●k,1        characterizing a state in a meta description domain;    -   a set of target features TFi●k,2={ft1, . . . , ftt}i●k,2 having        discrete or continuous range of values characterizing a target        for a considered state; and    -   a set AFi●k,3={fa1, . . . , faa}i●k,3 of actual features        AFi●k,3={fa1, . . . , faa}i●k,3 having discrete or continuous        range of values representing an actual constellation of a        considered state.

Further, the at least one meta object entity 20 references arepresentation entity specifying at least one representation object MO●Rrepresenting a set D●={d1●, . . . , do●} of descriptive features of ameta object type (MO●).

Further, the at least one meta object type MO● is perceivable underdifferent perspective views on the meta object type MOS being describedas a set P●={p1 e, . . . , pv●} of perspectives on the at least one metaobject type (MO●).

As shown in FIG. 12, the static meta model of the computer implementedmeta model comprises a functional entity 24 representing a statetransition in the at least one state model Σi● from a source state zi●ato a target state zi●t by a functional model Φi●at: Zi● x Xi●→Zi●representing a data flow model according to meta features, targetfeature, and/or actual features.

According to the present invention the functional entity 24 representsthe data flow model as a control flow operating on meta data and a dataflow operating on data reflecting target features and/or actualfeatures. Preferably, wherein the functional entity 24 represents thefunctional model as a meta data flow Φex,i●at or Φin,i●at as explainedabove, wherein both are summarized into Φ(ex, in),i●at in the following.

As shown in FIG. 12, the static meta model of the computer implementedmeta model comprises an input vector entity 26 representing a firstinput to the functional model Φ(ex,in)i●at as at least one state vectorΘ(ex,in),i●at,l summarizing at least one tuple of an identification of asubsystem and a state in which the identified subsystem prevails.

Further, the input vector entity 26 represents a second input to thefunctional model Φ(ex,in),i●at as a vector summarizing at least onecondition Δ(ex,in),i●at that must be met prior to a state transitionfrom a source state zi●a to a target state zi●t.

Further, the input vector entity 26 represents the at least onecondition as data reflecting at least one target feature and/or at leastone actual feature.

As shown in FIG. 12, the static meta model of the computer implementedmeta model comprises a context entity 28 representing at least onepotential relation between two twin objects representing digitalinstantiations of meta object types MO● as a set of contexts C={con_ID1,. . . , con_IDk} in the sense outlined above.

Further to the above, aside of the stat meta model the computerimplemented meta model 18 according to the present invention comprises adynamic meta model part which uses the modeling options available fromthe entities of the static meta models to come up with a specific metamodel of a subsystem of the distributed event-discrete system.

As shown in FIG. 12, the dynamic meta model of the computer implementedmeta model 18 for modelling at least one subsystem of a distributedevent-discrete system comprises a meta object type use module 30 adaptedto select a meta object type MO● for modeling of the at least onesubsystem of the distributed event-discrete system. As outlined above,the meta object type MO● references at least one state model Σi● i∈{1, .. . , s} for modeling of the at least one subsystem of the distributedevent-discrete system.

As shown in FIG. 12, the dynamic meta model of the computer implementedmeta model 18 comprises a state space model use module 32 adapted tomodel the at least one state model Σi● i∈{1, . . . , s} referenced bythe selected meta object type MO●.

As shown in FIG. 12, the modeling of the at least one state model Σi●i∈{1, . . . , s} is achieved through reference to the state space modelentity 22 provided modeling options in general which are thentransferred into model uses on the meta level by state space model usemodule 32.

Also, the state space model use module 32 is adapted to describe atleast one state in the selected at least one state model Σi● i=1, . . ., s with a meta model being a set of partial states zi●k,p usingdifferent levels of data abstraction as outlined above. As outlinedabove, different state models may have different associatedperspectives.

As shown in FIG. 12, the dynamic meta model of the computer implementedmeta model 18 comprises a representation use module adapted to model arepresentation object MO●R representing a set D●={d1●, . . . , do●} of odescriptive features of the modeled at least one subsystem. Here, alsothe representation use model references the representation entity of thestatic meta model to instantiate at least one of the descriptivefeatures described generally in the representation entity with respectto a specific modeling task.

As shown in FIG. 12, the dynamic meta model of the computer implementedmeta model 18 comprises a function use module 34 adapted to model astate transition in the at least one state model Σi● from a source statezi●a to a target state zi●t by the functional model representing a dataflow model according to meta features, target feature, and/or actualfeatures as described above.

As shown in FIG. 12, the modeling of the functional model is achievedthrough reference to the function entity 24 of the static meta modelproviding general options to model functions. The general options arethen transferred to a more specific function model through indication ofapplicable function transformations and indication of applicablearguments to realize the functional model Φex,i●at and/or the functionalmodel Φin,i●at as explained above.

Also, at least potential relation between at least two twin objectsrepresenting digital instantiations of meta object types may be modeledby at least one context as explained above.

As shown in FIG. 12, the dynamic meta model of the computer implementedmeta model 18 comprises a an input vector use module 36 adapted to modela first input to the functional model as external state vector orinternal state vector as outlined above. Heretofore, reference is madeto the input vector entity 26 of the static data model of the computerimplemented meta model which provides input vector templates and relatedparameters. A similar approach applies to the modeling of the secondvector specifying conditions for at least one state transition.

As shown in FIG. 12, the dynamic meta model part of the computeimplemented meta model 18 according to the present invention alsocomprises a twin/twin use module 38.

The provision of such a twin use module 38 serves to already prepare amodeling of components of the distributed event-discrete system whichper se are known to be a part of the distributed event-discrete system.

Thus, the related twin objects may be classified as pre-known or static,contrary to the digital twin object to be allocated in real-time duringtwin level modeling of the distributed event-discrete system to bedescribed in the following.

FIG. 13 shows a flowchart of operation for the modeling engine accordingto the present invention as shown in FIG. 10.

Generally, the modeling engine 12 according to the present inventionruns the computer implemented meta model explained above with respect toFIG. 12.

As shown in FIG. 13, the modeling engine 12 executes a step S18, byrunning the meta object type use module 30, to select a meta object typeMO● for modeling of the distributed event-discrete system. The metaobject type MO● references at least one state model Σi● i∈{1, . . . , s}for modeling of the at least one subsystem of the distributedevent-discrete system.

As shown in FIG. 13, the modeling engine 12 executes a step S20, byrunning the state space model use module 32, to select at least onestate model Σi● i∈{1, . . . , s} referenced by the meta object type MO●for actual use during modeling of the at least one subsystem. In thestep S20 the at least one state zi●k in the selected at least one statemodel Σi● i∈{1, . . . , s} is described with a meta model as outlinedabove.

As shown in FIG. 13, the modeling engine 12 executes a step S22, byrunning a related use module, to modeling a representation object MO●Rand to select at least one perspective view, which step S22 is optional.

As shown in FIG. 13, the modeling engine 12 executes a step S24, byrunning the function use module 32, to model a state transition in theat least one state model Σi● from a source state zi●a to a target statezi●t by a functional model representing a data flow model according tometa features, target feature, and/or actual features as explainedabove. Here, the data flow model describes a control flow operating onmeta data and a data flow operating on data reflecting target or actualfeatures.

As shown in FIG. 13, the modeling engine 12 executes a step S26, byrunning the input vector use module 36, to model input vectors to thefunctional model which represent external sate vectors and/or internalstate vectors as outlined above.

As shown in FIG. 13, the modeling engine 12 executes a step S28, byrunning the input vector use module 36, to model conditions for statetransitions, which step S28 is optional.

FIG. 14 shows a partitioning of a distributed event-discrete systemaccording to the present invention, wherein the partitioning is definedas a set of subsystem clusters such that all subsystems assigned to aspecific subsystem cluster are modeled with a same meta object type.

As outlined above, according to the present invention the differentlevels abstraction in the modelling of distributed event discretesystems—i.e., meta level, use level, and twin level—imply a partitioningof distributed event discrete systems into subsystems itself beingcomposed of digital twins.

Assuming the notion of distributed event-discrete systems, relatedsubsystems and streams between the subsystems a topic to be resolved formodelling of the distributed event-discrete system is how to partitionthe overall structure of the distributed event-discrete system into theat least one subsystem which may then be modeled using a related metaobject type MO● as described above.

Heretofore, initially it must be determined which of the available metaobject types MO● are indeed relevant for a particular case ofpartitioning of a distributed event-discrete system.

As shown in FIG. 14, according to the present invention meta object typebased partitioning according to the meta object type MO● impliesdefinition of subsystem clusters MOC={MO1, . . . , MOp} such that eachsubsystem cluster MOi∈MOC comprises at least one subsystem beingmodelled with a same meta model type MO●.

In more detail, let MOT=(type1, . . . , typet) be a set of all metaobject types MO● available for modelling of a distributed event discretesystem and the mapping MOT(MOi): MOi→type of MOi∈MOT be a function whichmaps a subsystem identification MOi to its related meta model type MO●.

Then meta object type based partitioning P(x)=G [SS, STR] (x) of thedistributed event-discrete system means that different subsystems of asubsystem cluster have a same meta model type MO●, i.e, that for allMOi, MOj∈MOCk with i≠j, MOT(MOi)=MOT (MOj)=MO●.

Further, a partitioning of the distributed event-discrete system P(x)may be represented as a digraph according to P(x)=G [SS, STR] (x). Inmore detail, SS={SS1, . . . , SSp} is a of subsystem clusters accordingto meta object types {MO1, . . . , MOp} and STR={STR1, . . . , STRq} isa set of streams between the subsystems of the distributedevent-discrete system. Here, subsystem clusters have common languagescope, semantics, and behavior of subsystems meta model, as well as acommon set of meta data, features and characteristics.

Further, according to the present invention within each subsystemcluster reflecting a certain meta object type MO● there are introducedsub-clusters of subsystems according to different uses of the subsystemsbeing modeled by the meta object type MO●.

Further, with respect to each subsystem cluster having meta model typeithere are described different use scenarios of the underlying meta modeltypei which use scenarios are modelled as subsystem use clustersMOUCi={MOUC1, . . . , MOUCu}i.

An outcome of the meta object type based partitioning and clustering isthat subsystems of the distributed event-discrete system are clusteredaccording to related meta object type MO●.

Within each subsystem cluster optionally there are described differentsubsystem use clusters having a same meta object type MO● but differentuses of the meta model type MO●.

Once a partitioning of the distributed event-discrete system isavailable a further point to be resolved for on the level of use levelmodeling is the setup of a routing topology for the exchange ofstreaming messages between subsystem clusters MOCi∈MOC.

As shown in FIG. 14, a routing topology is defined with respect to everysubsystem cluster MOCi∈MOC. In more detail for every subsystem clusterMOCi there is defined a set MOC_rec_i of at least one subsystem clusterfrom which the subsystem cluster MOCi receives streaming messages. Also,for every subsystem cluster MOCi there is defined a set HOC_send_i of atleast one subsystem cluster to which subsystem cluster MOCi sendsstreaming messages.

Then follows the setup of a routing topology between subsystem clustersof the distributed event-discrete system to proceed in the transitionfrom the meta level modelling to the use level modelling.

Further, a final step in the use-level modeling process relates to atransfer of the use-level modeling result into an executable softwareskeleton. The executable software skeleton serves to run a digital twinengine for control of a distributed even-discrete system in real-time.

In conclusion, the meta object type based partitioning significantlylowers the amount of data to be streamed between different subsystemclusters compared to a modelling approach where compositionalrepresentation is achieved on the level of digital twin objects withoutabstraction of modelling to a meta domain and use level domain.

The reason for this that on the streaming between different subsystemclusters is realized as meta streaming. Here, for each subsystem clusterthe related digital twin objects—sub-clustered according to meta modeltype use—broadcast data in relation to internal events of the subsystemcluster on a common streaming channel assigned to the subsystem clustermodelled with a specific meta object type MO●.

Otherwise, each other subsystem cluster receives data in relation toexternal events of a of a subsystem cluster of certain meta object typeMO● on meta streaming channel assigned for the other meta model type.

Overall, the number of streaming channels is dependent only on thenumber of subsystem clusters and related meta object types MO● and noton the number of actual subsystems and related twin objects. This has alarge influence on the complexity of the routing topology betweensubsystem clusters as the number of communication channels for acomplete communication process within the distributed event-discretesystem increases linearly with the number of meta object type MO● andnot exponentially with the number of actual subsystems.

Further, it should be noted that subsystems itself may be decomposedinto related further subsystems leading to introduction of hierarchyinto the overall modelling process.

FIG. 15 shows a schematic diagram of the service engine 14 according tothe present invention shown in FIG. 10, wherein the service engine 14generates a use model of at least one subsystem of a distributedevent-discrete system in line with a meta object type used to model theat least one subsystem.

As shown in FIG. 15, the service engine comprises a partitioning module40 adapted to partition the distributed event-discrete system into atleast two subsystem clusters each comprising at least one subsystem ofthe distributed event-discrete system as explained with respect to FIG.14. Here, all subsystems assigned to a specific subsystem clusterMOCi∈MOC are modeled with a same meta object type MO●.

As shown in FIG. 15, the service engine comprises a routing module 42adapted to define a routing topology for the exchange of streamingmessages between subsystem clusters MOCi∈MOC.

As shown in FIG. 15, the service engine comprises a use cluster module44 adapted to model different subsystem use clusters MOUCi={MOUC1, . . ., MOUCu}i for all subsystems assigned to a subsystem cluster of thedistributed event-discrete system.

Preferably, the routing topology defines for every subsystem clusterMOCi at least one external subsystem cluster from streaming messages arereceived and at least one external subsystem cluster to streamingmessages are sent.

As shown in FIG. 15, the service engine comprises a softwareconfiguration module 46 adapted to transform the use model of at leastone subsystem of a distributed event-discrete system into at least oneexecutable modeling software kernel that can run on a digital twinengine for real-time control of a distributed even-discrete system.

Preferably, the software configuration module 46 is adapted to:

-   -   configure the at least one executable modeling software kernel        per system cluster MOCi through parametrization of executable        software available from a software library; wherein    -   the at least one executable modeling software kernel is        configured to run at least one subsystem use model in relation        to every subsystem use of the subsystem cluster MOCi; and    -   the at least one executable modeling software kernel is        configured to run an input interface and an output interface for        exchange of at message streams having meta level message format        to and from the at least one executable modeling software        kernel.

Further, according to the present invention the software configurationmodule 46 is adapted to configure a routing topology between at leasttwo executable modeling software kernels by connecting related inputinterfaces and output interfaces via at least one meta streamcommunication channel.

Further, according to the present invention the software configurationmodule 46 is adapted to load the at least one executable modelingsoftware kernel into the digital twin engine for control of adistributed even-discrete system in real time.

FIG. 16 shows a flowchart of operation for the use level modelingaccording to the present invention as shown in FIG. 14 and FIG. 15,respectively.

As shown in FIG. 16, to achieve use level modeling according to thepresent invention there is executed a step S30, by running thepartitioning module 40 shown in FIG. 15, to partition the distributedevent-discrete system into at least two subsystem clusters eachcomprising at least one subsystem of the distributed event-discretesystem, wherein all subsystems assigned to a specific subsystem clusterMOCi∈MOC are modeled with a same meta object type MO●.

As shown in FIG. 16, subsequent to step S30 there is executed a stepS32, by running the routing module 42 shown in FIG. 15, to define arouting topology for the exchange of streaming messages betweensubsystem clusters MOCi∈ MOC.

Preferably, step 32 defines a routing topology by defining for everysubsystem cluster MOCi at least one external subsystem cluster fromstreaming messages are received and at least one external subsystemcluster to streaming messages are sent.

As shown in FIG. 16, subsequent to step S32 there is executed a stepS34, by running the use cluster module 42 shown in FIG. 15, to definedifferent subsystem use clusters MOUCi={MOUC1, . . . , MOUCu}i) for allsubsystems assigned to a subsystem cluster of the distributedevent-discrete system.

As shown in FIG. 16, subsequent to step S34 there is executed a stepS36, by running the software configuration module 46 shown in FIG. 15,to configure software to transform the use model of at least onesubsystem of a distributed event-discrete system into at least oneexecutable modeling software kernel that can run on a digital twinengine for real-time control of a distributed even-discrete system.

The specifics of the software configuration according t to step S36 havebeen outlined above with respect to FIG. 15 and therefore will not berepeated here.

Finally, during execution of step S36 the at least one executablemodeling software kernel is loaded into the virtual twin engine 16 forcontrol of a distributed even-discrete system in real time.

While above different aspects of the present invention being related tothe modeling of a distributed event-discrete system have been describedin the following the of the generated model for real time processcontrol of the distributed event-discrete system will be explained.

FIG. 17 shows a schematic diagram of a virtual twin engine 16 accordingto the present invention.

In the following it will be assumed that the virtual twin engine 16 haspre-installed at least one executable modeling software kernel preparedby the service engine 15 as shown in FIG. 15.

As outlined above, this implies a pre-installation of at least onemodeling software kernel per system cluster of the distributedeven-discrete system and related meta object type MO● used for metalevel modeling of the system cluster.

As shown in FIG. 17, the virtual twin engine 16 according to the presentinvention comprises a model processing module 48 adapted to run in realtime at least one subsystem use model in relation to the subsystemcluster through execution of a related modeling software kernel modelingthe at least one subsystem use model.

According to the present invention the model processing module 48 isadapted to operate at least one digital twin with respect to the atleast one subsystem use model as virtual counterpart to a relatedprocess object operated in the distributed even-discrete system andhaving a functionality in line with the subsystem use model.

Further, according to the present invention the model processing module48 is adapted to operate the at least one digital twin in a passivemanner through real time access to the modeling software kernel modelingthe subsystem use model of the at least one digital twin.

As shown in FIG. 17, the virtual twin engine 16 according to the presentinvention comprises a modeling engine interface 50 adapted to injectmodeling information into the module processing module 48 by activatingat least one meta object type MO● from all available meta object typesMO● supported by the modeling engine into the digital twin engine.

Preferably, the modeling engine interface 50 is adapted to inject a setof state models Σij, where i is the index to the state model and j isthe index to the related use, representing the comprising at least statemodel representing the meta object type MO● into the module processingmodule 48.

Further preferably, the modeling engine interface 50 is adapted toinject at least one perspective Pj on the injected at least one statemodel into the module processing module 48.

Further preferably, the modeling engine interface 50 is adapted toinject different levels of data abstraction according to meta data,target data, and actual data for each state model and related statevariables into the module processing module 48.

Further preferably, the modeling engine interface 50 is adapted toinject at least one subsystem use cluster with a predetermined metamodel type and at least one related digital twin. Here, the at least onedigital twin serves as a digital counterpart to a corresponding realworld process object.

As shown in FIG. 17, the virtual twin engine 16 according to the presentinvention comprises a service engine interface 52 adapted to injectsoftware code implementing external and/or internal state transitionsinto the module processing module 48.

As shown in FIG. 17, the virtual twin engine 16 according to the presentinvention comprises a modeling control module 54 adapted to initializeat least one related digital twin in relation to at least one subsystemuse cluster. Preferably, the modeling control module 54 is adapted toinitialize the at least one digital twin prior to start of the digitaltwin engine or in real time during operation of the digital twin engine.

As shown in FIG. 17, the virtual twin engine 16 according to the presentinvention comprises a data flow processing module 56 adapted to handlethe data exchange to/from the virtual twin engine.

As shown in FIG. 17, the virtual twin engine 16 according to the presentinvention comprises a data flow control module 58 adapted to the controldata exchange to/from the virtual twin engine by classifyingcommunication data according to different levels of abstraction into atleast control data flow and/or use data flow as will be explained inmore detail in the following.

As shown in FIG. 17, the virtual twin engine 16 according to the presentinvention comprises a meta stream input/output module 60 for exchange ofmeta stream messages to and from the virtual twin engine 16.

FIG. 18 shows a flowchart of operation for the virtual twin engine 16according to the present invention as shown in FIG. 17.

As shown in FIG. 18, to achieve real time process control of a modeldistributed event-discrete system the is executed a step S38, by runningthe model processing use module 48, to run in real time at least onesubsystem use model in relation to the subsystem cluster throughexecution of a related modeling software kernel modeling the at leastone subsystem use model.

As shown in FIG. 18, to achieve real time process control of a modeldistributed event-discrete system the is executed a step S40, by runningthe model processing use module 48, to operate at least one digital twinwith respect to the at least one subsystem use model as virtualcounterpart to a related process object operated in the distributedeven-discrete system and having a functionality in line with thesubsystem use model.

According to the present invention the step S40 of operating the atleast one digital twin is executed in a passive manner through real timeaccess to the modeling software kernel modeling the subsystem use modelof the at least one digital twin.

As shown in FIG. 18, to achieve real time process control of a modeldistributed event-discrete system there is executed a step S42, byrunning the model processing use module 48, to modify a model of thedistributed event-discrete system in real time throughinsertion/deletion of modeling components and/or digital twins.

Preferably, the step S42 is executed to inject modeling information byactivating at least one meta object type MO● from all available metaobject types MO● supported by the modeling engine 12 into the moduleprocessing module 48 of the virtual twin engine 16.

Preferably, the step S42 is executed to inject at least state models Σijcomprising at least state model representing the meta object type MO●into the module processing module 48 of the virtual twin engine 16.

Preferably, the step S42 is executed to inject at least one perspectivePj on the injected at least one state model into the module processingmodule 48 of the virtual twin engine 16.

Preferably, the step S42 is executed to inject different levels of dataabstraction according to meta data, target data, and actual data foreach state model and related state variables into the data flowprocessing module 56 of twin engine 16.

Preferably, the step S42 is executed to inject software codeimplementing external and/or internal state transitions into the moduleprocessing module 48 of the virtual twin machine 16.

Preferably, the step S42 is executed to inject at least one subsystemuse cluster with a predetermined meta object type into the moduleprocessing module 48 of the virtual twin machine 16.

As shown in FIG. 18, the step S42 is also executed initialize at leastone digital twin in relation to a subsystem use cluster, wherein the atleast one digital twin serves as a digital counterpart to acorresponding real world process object.

Preferably, the at least one digital twin is initialized prior to startof the virtual twin engine or during operation of the virtual twinengine for real time process control of the distributed event-discretesystem.

As shown in FIG. 18, to achieve real time process control of a modeldistributed event-discrete system there is executed a step S44, byrunning the data flow control module 88, to control data exchangeto/from the digital twin engine by classifying communication dataaccording to different levels of abstraction into at least control dataflow and/or use data flow.

Preferably, in step S44 there is evaluated at least one state vectorrepresenting at least one trigger event for at least one statetransition of a digital twin.

Further preferably, in step S44 the control data flow is controlled bygenerating at least one meta stream message in relation to a statetransition of a digital twin for exchange of related control databetween different subsystem clusters.

FIG. 19 shows further details of operation for the module processingmodule 48 as operated in the virtual twin engine 16.

As shown in FIG. 19, in the module processing unit 48 there run injectedfunctional software code implementing specific meta model types andrelated use models thereof.

Then, for every subsystem use cluster in every subsystem cluster thereis introduced at least one digital twin as digital counterpart in thedigital domain of a real world process object in the process domain. Toput it differently, each digital twin reflects the logical behavior of aprocess object in the domain to be modelled.

In more detail, for every subsystem use cluster MOUCk∈{MOUC1, . . . ,MOUCu} of a subsystem cluster having meta model typei there isinstantiated a set of at least one digital twin object TOk,i={to1, . . ., tol}k,i realizing a digital counterpart to a real world processobject.

It should be noted that the introduction of digital twins may beexecuted either prior to start of the digital twin engine or during realtime process control of the distributed event-discrete system. This isof significant importance as this real time configuration capability ofthe digital twin engine achieves a much higher flexibility andconfigurability in comparison to hard wired process control systems.

Further, as during initial configuration target values are not yetavailable so that they are declared according to type of data and arelated memory is allocated, Similarly, also actual values areconsidered through declaration of data type and memory allocation.

The outcome of the initial configuration is a set of executable softwarekernels in relation to subsystem use clusters.

Subsequent thereto running the virtual twin engine implies runningsubsystem use models in relation to subsystem uses of subsystem clustersin real time through execution of the modeling software kernel modelingthe subsystem use.

Further, at least one digital twin is operated with respect to everysubsystem use model as digital counterpart and in one-to-one relation toat least one process object which is operated in the distributedeven-discrete system and which has a functionality modeled by thedigital twin.

In particular the at least one at least one digital twin is operatedthrough real time access to the related modeling software kernel runningin real time. Thus, the behavior of a twin object is not explicitlymodelled but is inherited from the use level modelling stage.

Also, according to the present invention it is possible to trade off thesize of subsystem use clusters and the number of twins. In a first case,the size of each use cluster is one and the subsystem use clusters coverexactly one twin object. This is referred to as explicit modelling.Alternatively a subsystem use cluster may cover more than one twinobjects according to a 1:N relationship. This is referred to as implicitmodelling.

FIG. 20 shows a further detailed schematic diagram illustrating theoperation of the virtual twin engine 16 according to the presentinvention as shown in FIG. 17.

As shown in FIG. 20, another aspect of running the virtual twin engine16 according to the present invention relates to the data flow controlwith respect to the exchange of data to and from the virtual twin engine16.

As shown in FIG. 20, according to the present invention the control ofdata flow relies on dividing the data in different classes, e.g.,control data flow, use-level data flow in relation to the real-timeexecuting of the meta model type(s), use model type(s) and related twinobject(s). A further category of data may be related to process data,e.g., sensor/actuator data fed into and/or output by the digital twinengine.

It should be noted that according to the present invention the use-leveldata flow may be used to influence the control data flow. Also, theuse-level data flow may be specified on the use level of modeling andmay be evaluated on the twin level of modeling. Finally, statetransition related operative conditions are specifiable as use levelconditions or meta level conditions.

In view of the above, the separation between control data andmodel-related data according to the present invention is in line withthe computer-implemented meta model outlined above and allows to achievea significant efficiency increase during operation of the overallsystem.

As shown in FIG. 20, a first element of control data related data flowcontrol relates to the evaluation of external and/or internal statevectors representing triggering events for state transitions in the usemodels which model the operation of the digital twins.

As shown in FIG. 20, a second element of control data related data flowcontrol relates to the generation of meta stream messages for exchangewith subsystem clusters not being identical with the subsystem clusterwhere a state transition under consideration occurs.

As shown in FIG. 20, a first element of model-related data flow controlrelates to the evaluation of condition vectors representing conditionsfor state transitions in the use models which model the operation of thedigital twins. In more detail, such conditions are evaluated inconsideration of data representing actual or target values and inassociation with different states of the use-level state model operatedin relation to digital twins.

As shown in FIG. 20 and assuming that conditions for a particular statetransition are met, a second element of model-related data flow controlrelates to achievement of the actual transition from the initial stateto the target state. This implies application of the associatedtransformation function to data representing the initial state forgeneration of data representing the target state. Also, a transitionfrom the initial state to the target state necessitates at least oneupdate of context information in correspondence to the twin object forwhich the state transition is handled.

As shown in FIG. 20, a third element of model-related data flow controlrelates the processing of the state transition result(s). Here,information related to the target state is submitted to the secondelement of control data flow control, i.e. the generation of meta streammessages.

Once a state transition is terminated there is generated a related metastream message to inform other subsystem clusters with different metamodel type about the state transition.

Further, once a state transition is terminated it is also necessary toupdate the related state space model representation within the subsystemcluster where the related state space model is run.

As indicated above, a further category of data may be related to processdata, e.g., sensor/actuator data fed into and/or output by the digitaltwin engine. Here, related data is exchanged in real time between thetwin object representations and sensor/actuator interfaces of thedigital twin engine.

FIG. 21 shows a further detail flowchart of operation for the data flowprocessing module shown in FIGS. 17 and 20, respectively.

As shown in FIG. 21, according to the present invention the data flowcontrol module 52 is adapted to control a state vector evaluation module62 operating on the control data flow to evaluate at least one statevector representing at least one trigger event for at least one statetransition of a digital twin.

As shown in FIG. 21, the data flow control module 58 is adapted tocontrol a message generation module 64 operating on the control dataflow to generate at least one meta stream message in relation to a statetransition of a digital twin for exchange of related control databetween different subsystem clusters.

As shown in FIG. 21, the data flow control module 58 is adapted tocontrol a condition vector evaluation module 66 operating on the usedata flow to evaluate at least one condition vector comprising at leastan actual value and/or at least one target value in association with theat least one state transition of the at least one digital twin forevaluation of a related transition condition.

As shown in FIG. 21, the data flow control module 58 is adapted tocontrol an error evaluation module 68 operating on the use data flow toevaluate at least one condition indication to an error in the operationin the virtual twin engine 16. If an error occurs, then an errorhandling module 70 will either fix the problem so that the operation maybe resumed or terminate the overall operation of the virtual twin engine16.

As shown in FIG. 21, the data flow control module 58 is adapted tocontrol a transformation module 72 operating on the use data flow toapply at least one transformation function to data representing aninitial state prior to a state transition to generate data representinga target state after the state transition.

As shown in FIG. 21, the data flow control module 58 is adapted tocontrol an update module 74 operating on the use data flow to updatestate representation related information and optionally contextinformation in relation to a state transition.

In conclusion, according to the present invention there is proposed asplit of data flow into control data flow and use data flow. Thisreduces the complexity in communication and to improve a real timecapability as operations on control data flow and use data flow can,e.g., be parallelized. Also it enables increase in flexibility as usedata may have an impact on the control flow.

FIG. 22 shows an example of a seed-box approach used for evaluation ofstate vectors and condition vectors in the data flow processing moduleaccording to the present invention as shown in FIG. 17.

As outlined above, according to the present invention there areconsidered external state vectors triggering a state transition in astate space model upon occurrence of an event being external to thesubsystem cluster wherein the state model is used.

As outlined above, an 1-th external state vector Θex,i●at,l=((MOj, j≠●,zj), . . . , (MOk, k≠●, zk))T1 respectively summarizes tuples ofsubsystems external to a subsystem being modeled using the meta objettype MO● and corresponding states in which the external subsystemsindicated to prevail. Also, it was explained above that for differentsate transitions a plurality of external state vectors may exit.

According to the present invention one may assume without loss ofgenerality that different external state vectors per state transitionare established in relation to different contexts.

Also according to the present invention meta models are prepared asbasis for set-up of use-level models. Then for each dedicated use of aspecific meta model there is instantiated at least one digital twin asdigital counter part of a process object in the real world.

Form the above it should be clear that external state vectors asspecified on the meta level are replicated according to a number ofrelated digital twins and related different contexts accompanying astate transition of the digital twins.

Also, for each use model being operated in the virtual twin engine thereis operated a at least one related state space model. Assuming that foreach use model there is instantiated at least one digital twin then forevery state in the related state space model there is considered atleast one use of state per twin or equivalently state use per digitaltwin.

To put it differently, assuming that for a particular use model aplurality of twins are instantiated then for each state of the relatedstate space model on the use level of abstraction there will beconsidered a corresponding plurality of state uses on the twin level ofabstraction.

From the above and as shown in FIG. 22, the conclusion is that for everyset of external state vectors per subsystem type and a related subsystemtype use may be organized into a matrix form where rows correspond tothe state uses with respect to digital twins of the subsystem use modeland columns represent different context(s) for state transitionsconsidered on the twin level of model abstraction.

FIG. 23 shows a further example of a seed-box approach for evaluation ofstate vectors and condition vectors in the data flow processing moduleaccording to the present invention as shown in FIG. 17.

As shown in FIG. 23, according to the present invention seed-boxes areprepared for every subsystem cluster of the use-level model of adistributed event-discrete system.

According to the present invention the preparation of the seed boxes isin line with the routing topology on the use-level abstraction ofmodeling.

In more detail and as shown in FIG. 23, for every subsystem clusterthere will be prepared a seed box in relation to every other subsystemcluster to which the considered subsystem cluster listens. Further,there will be prepared a seed box in relation to in relation to eachmeta object type which is applicable in the other subsystem cluster towhich the considered subsystem cluster listens. Finally, seed boxes willalso be prepared for the handling of internal state transitions of statespace models which are operated internally within a subsystem cluster.

FIG. 24 shows an example of updating a seed-box as shown in FIGS. 22 and23 after execution of a state transition with respect to a twin object.

As is shown in FIG. 24, an efficient way to represent a matrix of stateuses versus contexts as shown in FIG. 22 in a sparse manner is to use alinked list of twin/context pairs with respect to every state use. Then,once a twin executes a state transition this implies the cancelation ofthe related twin/context pair from a first list in relation to thesource state of the state transition and the addition of an updatedtwin/context pair to a second list in relation to the target state ofthe state transition.

While in the above, the present invention has been described withreference to the drawings and figures of preferred embodiments of theinvention, it should be noted that clearly the present invention mayalso be implemented using variations and modifications thereof whichwill be apparent and can be readily made by those skilled in the artwithout departing from the scope and spirit of the present invention.E.g., functionalities described above may be realized in software, inhardware, or a combination thereof.

Accordingly, it is not intended that the scope of claims appended heretois limited to the description as set forth herein, but rather that theclaims should be construed so as to encompass all features ofpresentable novelty that preside in the present invention, including allfeatures that would be treated as equivalent thereof by those skilled inthe art to which the present invention pertains.

Glossary Vectors and Sets:

-   x=(x1, . . . , xk) T input vector-   X set of input vectors-   y=(y1, . . . , yn) T output vector-   Y set of output vectors-   z=(z1, . . . , zm) T state variable vector-   Z set of state variable vectors-   SS={SS1, . . . , SSp} set of mutually disjoint subsystems of a    distributed event discrete system-   STR={STR1, . . . , STRq} set of streams between subsystems of a    distributed event discrete system-   MOC={MOC1, . . . , MOCp} set of subsystem clusters describing a    partitioning of a distributed event discrete system-   MOC_rec_i set of at least one subsystem cluster from which the    subsystem cluster MOCi receives streaming messages-   MOC_send_i set of at least one subsystem cluster to which subsystem    cluster MOCi sends streaming messages-   MOT={MOT1, . . . , MOTp} set of meta object types available for    modeling of a distributed event-discrete system-   MOUCi={MOUC1, . . . , MOUCui}i subsystem use clusters of subsystems    within a subsystem being modelled with a specific meta object type    typei-   MO●R representation object of meta object type MO●-   D●={d1, . . . , do} set of descriptive features of the meta object    type MO●-   External state vector for meta object type MO●: Θex,i●at,l=((SSTj,    j≠●, zj), . . . , (SSTk, k≠●, zk))lT-   πex,i●at=Ul Θex,i●at,l set of all external state vectors triggering    a state transition due to an external event being relevant for meta    object type MOT●-   Δex,i●a set of conditions that must be met prior to triggering a    state transition due to an external event being relevant for meta    object type MOT●-   πin,i●at set of internal state vectors triggering a state transition    due to an internal event being relevant for meta object type MOT●-   Δin,i●a set of conditions that must be met prior to triggering a    state transition due to an internal event being relevant for meta    object type MOT●-   C=(con_ID1, . . . , con_IDn) set of contexts

Functions:

-   Φ state transition function-   Φin state transitions due to internal events-   Φex state transitions due to external events-   Ω output function-   τ retention time function

Operators and Models:

-   S system operator-   Σ=<X, Z, Y, Φin, Φx, Ω, τ> state model of a distributed    event-discrete system-   P(x)=G [SS, STR](x) digraph representation of a compositional    partition of a distributed event-discrete system-   Σi● i-th state model used in the static data model of partial    subsystem TS●-   ● placeholder for an arbitrary but fixed element

1. Method of running a virtual twin engine for control of a distributedeven-discrete system in real-time, wherein the virtual twin engine hasinstalled at least one executable modeling software kernel which isprepared by generating a meta model representation for at least onesubsystem of a distributed event-discrete system by selecting from ameta model a meta object type (MO●) referencing at least one state model(Σi●i∈{1, . . . , s}) for modeling of the at least one subsystem of thedistributed event-discrete system, wherein at least one state (zi●k) inthe selected at least one state model (Σi●i∈{1, . . . , s}) is describedwith a meta model being a set of partial states (zi●k,p) using differentlevels of data abstraction according to set of meta featurescharacterizing a state in a meta description domain, a set of targetfeatures having discrete or continuous range of values characterizing atarget for a considered state, and a set of actual features havingdiscrete or continuous range of values characterizing an actualconstellation of a considered state; partitioning the distributedevent-discrete system into at least two subsystem clusters eachcomprising at least one subsystem of the distributed event-discretesystem having a same meta model representation; defining a routingtopology for the exchange of streaming messages between subsystemclusters; modeling at least one subsystem use cluster for at least onesubsystem assigned to a subsystem cluster of the distributedevent-discrete system; and configuring the at least one executablemodeling software kernel to run the routing topology and at least onesubsystem use model in relation to every subsystem use of the subsystemcluster through parametrization of executable software available from asoftware library; the method of running the virtual twin enginecomprising: a step of running in real time at least one subsystem usemodel in relation to the subsystem cluster through execution of arelated modeling software kernel modeling the at least one subsystem usemodel; a step of operating at least one digital twin with respect to theat least one subsystem use model as virtual counterpart to a relatedprocess object operated in the distributed even-discrete system andhaving a functionality in line with the subsystem use model; wherein thestep of operating the at least one digital twin is executed in a passivemanner through real time access to the modeling software kernel modelingthe subsystem use model of the at least one digital twin.
 2. Methodaccording to claim 1, comprising a step of injecting at least oneelement into the virtual state machine which element is selected from agroup comprising: modeling information reflecting at least one metaobject type (MO●)into the virtual twin engine; a set of state models(Σij) comprising at least one state model references by the meta objecttype (MO●) into the virtual twin engine; at least one perspectiverepresenting a view on the injected at least one state model into thevirtual twin engine; different levels of data abstraction according tometa data, target data, and actual data for each state model and relatedstate variables into the virtual twin engine; software code implementingexternal and/or internal state transitions into the virtual twinmachine; and at least one subsystem use cluster with a predeterminedmeta model type.
 3. Method according to claim 1, comprising a step ofinitializing at least one digital twin in relation to a subsystem usecluster, wherein the at least one digital twin serves as a digitalcounterpart to a corresponding real world process object.
 4. Methodaccording to claim 3, wherein the step of initializing at least onedigital twin is executed prior to start of the virtual twin engine orduring operation of the virtual twin engine for real time processcontrol of the distributed event-discrete system.
 5. Method according toclaim 1, comprising a step of controlling data exchange to/from thedigital twin engine by classifying communication data according todifferent levels of abstraction into at least control data flow and/oruse data flow.
 6. Method according to claim 5, comprising a step ofcontrolling the control data flow by evaluation of at least one statevector representing at least one trigger event for at least one statetransition of a digital twin.
 7. Method according to claim 5, comprisinga step of controlling the control data flow by generating at least onemeta stream message in relation to a state transition of a digital twinfor exchange of related control data between different subsystemclusters.
 8. Method according to claim 5, comprising a step ofcontrolling the use data flow by evaluating at least one conditionvector comprising at least an actual value and/or at least one targetvalue in association with the at least one state transition of the atleast one digital twin for evaluation of a related transition condition.9. Method according to claim 5, comprising a step of controlling the usedata flow by executing at least one step selected from a groupcomprising applying at least one transformation function to datarepresenting an initial state prior to a state transition to generatedata representing a target state after the state transition; updating atleast one context information in relation to the state transition; andprocessing of a state transition result for generation of at least onemeta stream message for update of at least one state model in asubsystem use cluster being external of the subsystem use cluster of thedigital twin executing the state transition.
 10. Virtual twin engine forcontrol of a distributed even-discrete system in real-time, wherein thevirtual twin engine has installed at least one executable modelingsoftware kernel prepared by generating a meta model representation forat least one subsystem of a distributed event-discrete system byselecting from a meta model a meta object type (MO●) referencing atleast one state model (Σi●i∈{1, . . . , s}) for modeling of the at leastone subsystem of the distributed event-discrete system, wherein at leastone state (zi●k) in the selected at least one state model (Σi●i∈{1, . .. , s}) is described with a meta model being a set of partial states(zi●k,p) using different levels of data abstraction according to set ofmeta features characterizing a state in a meta description domain, a setof target features having discrete or continuous range of valuescharacterizing a target for a considered state, and a set of actualfeatures having discrete or continuous range of values characterizing anactual constellation of a considered state; partitioning the distributedevent-discrete system into at least two subsystem clusters eachcomprising at least one subsystem of the distributed event-discretesystem having a same meta model representation; defining a routingtopology for the exchange of streaming messages between subsystemclusters; modeling at least one subsystem use cluster for at least onesubsystem assigned to a subsystem cluster of the distributedevent-discrete system; and configuring the at least one executablemodeling software kernel to run the routing topology and at least onesubsystem use model in relation to every subsystem use of the subsystemcluster through parametrization of executable software available from asoftware library; the virtual twin engine comprising: a model processingmodule adapted to run in real time at least one subsystem use model inrelation to the subsystem cluster through execution of a relatedmodeling software kernel modeling the at least one subsystem use model;wherein the model processing module is adapted to operate at least onedigital twin with respect to the at least one subsystem use model asvirtual counterpart to a related process object operated in thedistributed even-discrete system and having a functionality in line withthe subsystem use model; and the model processing module is adapted tooperate the at least one digital twin in a passive manner through realtime access to the modeling software kernel modeling the subsystem usemodel of the at least one digital twin.
 11. Virtual twin engineaccording to claim 10, comprising a modeling engine interface adapted toinject at least one element into the virtual state machine which elementis selected from a group comprising: modeling information reflecting atleast one meta object type (MO●) into the virtual twin engine; a set ofstate models (Σij) comprising at least one state model references by themeta object type (MO●) into the virtual twin engine; at least oneperspective representing a view on the injected at least one state modelinto the virtual twin engine; different levels of data abstractionaccording to meta data, target data, and actual data for each statemodel and related state variables into the virtual twin engine; softwarecode implementing external and/or internal state transitions into thevirtual twin machine; and at least one subsystem use cluster with apredetermined meta model type.
 12. Virtual twin engine according toclaim 10, comprising a modeling control module adapted to inject atleast one digital twin in relation to a subsystem use cluster, whereinthe at least one digital twin serves as a digital counterpart to acorresponding real world process object.
 13. Virtual twin engineaccording to claim 12, wherein modeling control module is adapted toinitialize the at least one digital twin prior to start of the digitaltwin engine or in real time during operation of the virtual twin engine.14. Virtual twin engine according to claim 10, comprising a serviceengine interface adapted to inject software code implementing externaland/or internal state transitions into the virtual twin engine. 15.Virtual twin engine according to claim 10, comprising a data flowcontrol module adapted to control data exchange to/from the digital twinengine by classifying communication data according to different levelsof abstraction into at least control data flow and/or use data flow. 16.Virtual twin engine according to claim 15, wherein the data flow controlmodule is adapted to control a state vector evaluation module operatingon the control data flow to evaluate at least one state vectorrepresenting at least one trigger event for at least one statetransition of a digital twins.
 17. Virtual twin engine according toclaim 15, wherein the data flow control module is adapted to control astate vector evaluation module operating on the control data flow togenerate at least one meta stream message in relation to a statetransition of a digital twin for exchange of related control databetween different subsystem clusters.
 18. Virtual twin engine accordingto claim 15, wherein the data flow control module is adapted to controla condition vector evaluation module operating on the use data flow toevaluate at least one condition vector comprising at least an actualvalue and/or at least one target value in association with the at leastone state transition of the at least one digital twin for evaluation ofa related transition condition.
 19. Virtual twin engine according toclaim 15, wherein the data flow control module is adapted to control atransformation module operating on the use data flow to apply at leastone transformation function to data representing an initial state priorto a state transition to generate data representing a target state afterthe state transition.
 20. Virtual twin engine according to claim 15,wherein the data flow control module is adapted to control an updatemodule operating on the use data flow to update at least one contextinformation in relation to the state transition.
 21. Virtual twin engineaccording to claim 15, wherein the data flow control module is adaptedto control a message generation module operating on the control dataflow to generate at least one meta stream message for update of at leastone state model in a subsystem use cluster external to the subsystem usecluster of the digital twin executing the state transition.